package demo2;

//函数式接口
@FunctionalInterface
interface NPNR {
    //只能有有一个方法
    void test();
}

//有一个参数无返回值
interface OPNR {
    void test(int a);
}

//有一个参数一个返回值
interface OPOR {
    int test(int a);
}

interface MPNR {
    void test(int a, int b);
}

interface NPR {
    int test();
}

interface OPR {
    int test(int a);
}

interface MPR {
    int test(int a, int b);
}

public class Test {
    public static void main(String[] args) {
        /*OPNR opnr = a -> {
            System.out.println("这是有一个参数，无返回值的 lambda表达式");
        };*/
        //因为只有一个参数，所以可以把前面的括号省略
        OPNR opnr = (a) -> {
            System.out.println("这是有一个参数，无返回值的 lambda表达式");
        };
        opnr.test(1);

        OPOR opor = a -> {
            System.out.println("有一个参数，一个返回值");
            return 5;
        };
        opor.test(5);

        MPNR mpnr = (a, b) -> {
            System.out.println("两个参数，没有返回值");
            System.out.println(a + b);
        };
        mpnr.test(1, 2);

        NPR npr = () -> {
            System.out.println("没有参数，一个返回值");
            return 10;
        };
        npr.test();

        OPR opr = (a) -> {
            System.out.println("一个参数，一个返回值");
            return 10;
        };
        opr.test(10);

        MPR mpr = (a, b) -> {
            System.out.println("有多个参数，一个返回值");
            return 20;
        };
        mpr.test(10, 20);

    }
    public static void main1(String[] args) {
        //此时我们先不使用 lambda 表达式
        NPNR npnr1 = new NPNR() {
            @Override
            public void test() {
                System.out.println("这是一个匿名内部类，里面重写了 test() 方法");
            }
            //这个类实现了test并重写，因为是匿名内部类，所以这个类没有名字
        };

        //我们使用 lambda 表达式来进行修改
        NPNR npnr2 = () -> System.out.println("使用 lambda 表达式重写了 test 方法");
        NPNR npnr3 = () -> {
            System.out.println("因为这里有多条语句，所以用大括号");
            System.out.println("前面小括号不能省略");
        };
        npnr1.test();
        npnr2.test();
        npnr3.test();
    }
}
